angular-loader.js ➔ minErr - Code Metrics - Otaku-Projects/AngularJS-CRUD-PHP - Measure and Improve Code Quality continuously with Scrutinizer

angular-loader.js ➔ minErr B
last analyzed 2020-01-16 17:41 UTC

↳ Parent: third-party/angularjs/angular-1.5.0/angular-loader.js

Complexity

Conditions

Size

Total Lines	33
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	7
eloc	21
dl	0
loc	33
rs	7.9759
c	0
b	0
f	0

/**
 * @license AngularJS v1.5.0
 * (c) 2010-2016 Google, Inc. http://angularjs.org
 * License: MIT
 */

(function() {'use strict';
    function isFunction(value) {return typeof value === 'function';};

/* global: toDebugString: true */

function serializeObject(obj) {
  var seen = [];

  return JSON.stringify(obj, function(key, val) {
    val = toJsonReplacer(key, val);
    if (isObject(val)) {

      if (seen.indexOf(val) >= 0) return '...';

      seen.push(val);
    }
    return val;
  });
}

function toDebugString(obj) {
  if (typeof obj === 'function') {
    return obj.toString().replace(/ \{[\s\S]*$/, '');
  } else if (isUndefined(obj)) {
    return 'undefined';
  } else if (typeof obj !== 'string') {
    return serializeObject(obj);
  }
  return obj;
}

/**
 * @description
 *
 * This object provides a utility for producing rich Error messages within
 * Angular. It can be called as follows:
 *
 * var exampleMinErr = minErr('example');
 * throw exampleMinErr('one', 'This {0} is {1}', foo, bar);
 *
 * The above creates an instance of minErr in the example namespace. The
 * resulting error will have a namespaced error code of example.one.  The
 * resulting error will replace {0} with the value of foo, and {1} with the
 * value of bar. The object is not restricted in the number of arguments it can
 * take.
 *
 * If fewer arguments are specified than necessary for interpolation, the extra
 * interpolation markers will be preserved in the final string.
 *
 * Since data will be parsed statically during a build step, some restrictions
 * are applied with respect to how minErr instances are created and called.
 * Instances should have names of the form namespaceMinErr for a minErr created
 * using minErr('namespace') . Error codes, namespaces and template strings
 * should all be static strings, not variables or general expressions.
 *
 * @param {string} module The namespace to use for the new minErr instance.
 * @param {function} ErrorConstructor Custom error constructor to be instantiated when returning
 *   error from returned function, for cases when a particular type of error is useful.
 * @returns {function(code:string, template:string, ...templateArgs): Error} minErr instance
 */

function minErr(module, ErrorConstructor) {
  ErrorConstructor = ErrorConstructor || Error;
  return function() {
    var SKIP_INDEXES = 2;

    var templateArgs = arguments,
      code = templateArgs[0],
      message = '[' + (module ? module + ':' : '') + code + '] ',
      template = templateArgs[1],
      paramPrefix, i;

    message += template.replace(/\{\d+\}/g, function(match) {
      var index = +match.slice(1, -1),
        shiftedIndex = index + SKIP_INDEXES;

      if (shiftedIndex < templateArgs.length) {
        return toDebugString(templateArgs[shiftedIndex]);
      }

      return match;
    });

    message += '\nhttp://errors.angularjs.org/1.5.0/' +
      (module ? module + '/' : '') + code;

    for (i = SKIP_INDEXES, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') {
      message += paramPrefix + 'p' + (i - SKIP_INDEXES) + '=' +
        encodeURIComponent(toDebugString(templateArgs[i]));
    }

    return new ErrorConstructor(message);
  };
}

/**
 * @ngdoc type
 * @name angular.Module
 * @module ng
 * @description
 *
 * Interface for configuring angular {@link angular.module modules}.
 */

function setupModuleLoader(window) {

  var $injectorMinErr = minErr('$injector');
  var ngMinErr = minErr('ng');

  function ensure(obj, name, factory) {
    return obj[name] || (obj[name] = factory());
  }

  var angular = ensure(window, 'angular', Object);

  // We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
  angular.$$minErr = angular.$$minErr || minErr;

  return ensure(angular, 'module', function() {
    /** @type {Object.<string, angular.Module>} */
    var modules = {};

    /**
     * @ngdoc function
     * @name angular.module
     * @module ng
     * @description
     *
     * The `angular.module` is a global place for creating, registering and retrieving Angular
     * modules.
     * All modules (angular core or 3rd party) that should be available to an application must be
     * registered using this mechanism.
     *
     * Passing one argument retrieves an existing {@link angular.Module},
     * whereas passing more than one argument creates a new {@link angular.Module}
     *
     *
     * # Module
     *
     * A module is a collection of services, directives, controllers, filters, and configuration information.
     * `angular.module` is used to configure the {@link auto.$injector $injector}.
     *
     * ```js
     * // Create a new module
     * var myModule = angular.module('myModule', []);
     *
     * // register a new service
     * myModule.value('appName', 'MyCoolApp');
     *
     * // configure existing services inside initialization blocks.
     * myModule.config(['$locationProvider', function($locationProvider) {
     *   // Configure existing providers
     *   $locationProvider.hashPrefix('!');
     * }]);
     * ```
     *
     * Then you can create an injector and load your modules like this:
     *
     * ```js
     * var injector = angular.injector(['ng', 'myModule'])
     * ```
     *
     * However it's more likely that you'll just use
     * {@link ng.directive:ngApp ngApp} or
     * {@link angular.bootstrap} to simplify this process for you.
     *
     * @param {!string} name The name of the module to create or retrieve.
     * @param {!Array.<string>=} requires If specified then new module is being created. If
     *        unspecified then the module is being retrieved for further configuration.
     * @param {Function=} configFn Optional configuration function for the module. Same as
     *        {@link angular.Module#config Module#config()}.
     * @returns {angular.Module} new module with the {@link angular.Module} api.
     */
    return function module(name, requires, configFn) {
      var assertNotHasOwnProperty = function(name, context) {
        if (name === 'hasOwnProperty') {
          throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
        }
      };

      assertNotHasOwnProperty(name, 'module');
      if (requires && modules.hasOwnProperty(name)) {
        modules[name] = null;
      }
      return ensure(modules, name, function() {
        if (!requires) {
          throw $injectorMinErr('nomod', "Module '{0}' is not available! You either misspelled " +
             "the module name or forgot to load it. If registering a module ensure that you " +
             "specify the dependencies as the second argument.", name);
        }

        /** @type {!Array.<Array.<*>>} */
        var invokeQueue = [];

        /** @type {!Array.<Function>} */
        var configBlocks = [];

        /** @type {!Array.<Function>} */
        var runBlocks = [];

        var config = invokeLater('$injector', 'invoke', 'push', configBlocks);

        /** @type {angular.Module} */
        var moduleInstance = {
          // Private state
          _invokeQueue: invokeQueue,
          _configBlocks: configBlocks,
          _runBlocks: runBlocks,

          /**
           * @ngdoc property
           * @name angular.Module#requires
           * @module ng
           *
           * @description
           * Holds the list of modules which the injector will load before the current module is
           * loaded.
           */
          requires: requires,

          /**
           * @ngdoc property
           * @name angular.Module#name
           * @module ng
           *
           * @description
           * Name of the module.
           */
          name: name,


          /**
           * @ngdoc method
           * @name angular.Module#provider
           * @module ng
           * @param {string} name service name
           * @param {Function} providerType Construction function for creating new instance of the
           *                                service.
           * @description
           * See {@link auto.$provide#provider $provide.provider()}.
           */
          provider: invokeLaterAndSetModuleName('$provide', 'provider'),

          /**
           * @ngdoc method
           * @name angular.Module#factory
           * @module ng
           * @param {string} name service name
           * @param {Function} providerFunction Function for creating new instance of the service.
           * @description
           * See {@link auto.$provide#factory $provide.factory()}.
           */
          factory: invokeLaterAndSetModuleName('$provide', 'factory'),

          /**
           * @ngdoc method
           * @name angular.Module#service
           * @module ng
           * @param {string} name service name
           * @param {Function} constructor A constructor function that will be instantiated.
           * @description
           * See {@link auto.$provide#service $provide.service()}.
           */
          service: invokeLaterAndSetModuleName('$provide', 'service'),

          /**
           * @ngdoc method
           * @name angular.Module#value
           * @module ng
           * @param {string} name service name
           * @param {*} object Service instance object.
           * @description
           * See {@link auto.$provide#value $provide.value()}.
           */
          value: invokeLater('$provide', 'value'),

          /**
           * @ngdoc method
           * @name angular.Module#constant
           * @module ng
           * @param {string} name constant name
           * @param {*} object Constant value.
           * @description
           * Because the constants are fixed, they get applied before other provide methods.
           * See {@link auto.$provide#constant $provide.constant()}.
           */
          constant: invokeLater('$provide', 'constant', 'unshift'),

           /**
           * @ngdoc method
           * @name angular.Module#decorator
           * @module ng
           * @param {string} The name of the service to decorate.
           * @param {Function} This function will be invoked when the service needs to be
           *                                    instantiated and should return the decorated service instance.
           * @description
           * See {@link auto.$provide#decorator $provide.decorator()}.
           */
          decorator: invokeLaterAndSetModuleName('$provide', 'decorator'),

          /**
           * @ngdoc method
           * @name angular.Module#animation
           * @module ng
           * @param {string} name animation name
           * @param {Function} animationFactory Factory function for creating new instance of an
           *                                    animation.
           * @description
           *
           * **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
           *
           *
           * Defines an animation hook that can be later used with
           * {@link $animate $animate} service and directives that use this service.
           *
           * ```js
           * module.animation('.animation-name', function($inject1, $inject2) {
           *   return {
           *     eventName : function(element, done) {
           *       //code to run the animation
           *       //once complete, then run done()
           *       return function cancellationFunction(element) {
           *         //code to cancel the animation
           *       }
           *     }
           *   }
           * })
           * ```
           *
           * See {@link ng.$animateProvider#register $animateProvider.register()} and
           * {@link ngAnimate ngAnimate module} for more information.
           */
          animation: invokeLaterAndSetModuleName('$animateProvider', 'register'),

          /**
           * @ngdoc method
           * @name angular.Module#filter
           * @module ng
           * @param {string} name Filter name - this must be a valid angular expression identifier
           * @param {Function} filterFactory Factory function for creating new instance of filter.
           * @description
           * See {@link ng.$filterProvider#register $filterProvider.register()}.
           *
           * <div class="alert alert-warning">
           * **Note:** Filter names must be valid angular {@link expression} identifiers, such as `uppercase` or `orderBy`.
           * Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
           * your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
           * (`myapp_subsection_filterx`).
           * </div>
           */
          filter: invokeLaterAndSetModuleName('$filterProvider', 'register'),

          /**
           * @ngdoc method
           * @name angular.Module#controller
           * @module ng
           * @param {string|Object} name Controller name, or an object map of controllers where the
           *    keys are the names and the values are the constructors.
           * @param {Function} constructor Controller constructor function.
           * @description
           * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
           */
          controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'),

          /**
           * @ngdoc method
           * @name angular.Module#directive
           * @module ng
           * @param {string|Object} name Directive name, or an object map of directives where the
           *    keys are the names and the values are the factories.
           * @param {Function} directiveFactory Factory function for creating new instance of
           * directives.
           * @description
           * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
           */
          directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'),

          /**
           * @ngdoc method
           * @name angular.Module#component
           * @module ng
           * @param {string} name Name of the component in camel-case (i.e. myComp which will match as my-comp)
           * @param {Object} options Component definition object (a simplified
           *    {@link ng.$compile#directive-definition-object directive definition object})
           *
           * @description
           * See {@link ng.$compileProvider#component $compileProvider.component()}.
           */
          component: invokeLaterAndSetModuleName('$compileProvider', 'component'),

          /**
           * @ngdoc method
           * @name angular.Module#config
           * @module ng
           * @param {Function} configFn Execute this function on module load. Useful for service
           *    configuration.
           * @description
           * Use this method to register work which needs to be performed on module loading.
           * For more about how to configure services, see
           * {@link providers#provider-recipe Provider Recipe}.
           */
          config: config,

          /**
           * @ngdoc method
           * @name angular.Module#run
           * @module ng
           * @param {Function} initializationFn Execute this function after injector creation.
           *    Useful for application initialization.
           * @description
           * Use this method to register work which should be performed when the injector is done
           * loading all modules.
           */
          run: function(block) {
            runBlocks.push(block);
            return this;
          }
        };

        if (configFn) {
          config(configFn);
        }

        return moduleInstance;

        /**
         * @param {string} provider
         * @param {string} method
         * @param {String=} insertMethod
         * @returns {angular.Module}
         */
        function invokeLater(provider, method, insertMethod, queue) {
          if (!queue) queue = invokeQueue;
          return function() {
            queue[insertMethod || 'push']([provider, method, arguments]);
            return moduleInstance;
          };
        }

        /**
         * @param {string} provider
         * @param {string} method
         * @returns {angular.Module}
         */
        function invokeLaterAndSetModuleName(provider, method) {
          return function(recipeName, factoryFunction) {
            if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
            invokeQueue.push([provider, method, arguments]);
            return moduleInstance;
          };
        }
      });
    };
  });

}

setupModuleLoader(window);
})(window);

/**
 * Closure compiler type information
 *
 * @typedef { {
 *   requires: !Array.<string>,
 *   invokeQueue: !Array.<Array.<*>>,
 *
 *   service: function(string, Function):angular.Module,
 *   factory: function(string, Function):angular.Module,
 *   value: function(string, *):angular.Module,
 *
 *   filter: function(string, Function):angular.Module,
 *
 *   init: function(Function):angular.Module
 * } }
 */
angular.Module;




1		/**
2		* @license AngularJS v1.5.0
3		* (c) 2010-2016 Google, Inc. http://angularjs.org
4		* License: MIT
5		*/
6
7		(function() {'use strict';
8		function isFunction(value) {return typeof value === 'function';};
9
10		/* global: toDebugString: true */
11
12		function serializeObject(obj) {
13		var seen = [];
14
15		return JSON.stringify(obj, function(key, val) {
16		val = toJsonReplacer(key, val);
17		if (isObject(val)) {
18
19		if (seen.indexOf(val) >= 0) return '...';
20
21		seen.push(val);
22		}
23		return val;
24		});
25		}
26
27		function toDebugString(obj) {
28		if (typeof obj === 'function') {
29		return obj.toString().replace(/ \{[\s\S]*$/, '');
30		} else if (isUndefined(obj)) {
31		return 'undefined';
32		} else if (typeof obj !== 'string') {
33		return serializeObject(obj);
34		}
35		return obj;
36		}
37
38		/**
39		* @description
40		*
41		* This object provides a utility for producing rich Error messages within
42		* Angular. It can be called as follows:
43		*
44		* var exampleMinErr = minErr('example');
45		* throw exampleMinErr('one', 'This {0} is {1}', foo, bar);
46		*
47		* The above creates an instance of minErr in the example namespace. The
48		* resulting error will have a namespaced error code of example.one. The
49		* resulting error will replace {0} with the value of foo, and {1} with the
50		* value of bar. The object is not restricted in the number of arguments it can
51		* take.
52		*
53		* If fewer arguments are specified than necessary for interpolation, the extra
54		* interpolation markers will be preserved in the final string.
55		*
56		* Since data will be parsed statically during a build step, some restrictions
57		* are applied with respect to how minErr instances are created and called.
58		* Instances should have names of the form namespaceMinErr for a minErr created
59		* using minErr('namespace') . Error codes, namespaces and template strings
60		* should all be static strings, not variables or general expressions.
61		*
62		* @param {string} module The namespace to use for the new minErr instance.
63		* @param {function} ErrorConstructor Custom error constructor to be instantiated when returning
64		* error from returned function, for cases when a particular type of error is useful.
65		* @returns {function(code:string, template:string, ...templateArgs): Error} minErr instance
66		*/
67
68		function minErr(module, ErrorConstructor) {
69		ErrorConstructor = ErrorConstructor \|\| Error;
70		return function() {
71		var SKIP_INDEXES = 2;
72
73		var templateArgs = arguments,
74		code = templateArgs[0],
75		message = '[' + (module ? module + ':' : '') + code + '] ',
76		template = templateArgs[1],
77		paramPrefix, i;
78
79		message += template.replace(/\{\d+\}/g, function(match) {
80		var index = +match.slice(1, -1),
81		shiftedIndex = index + SKIP_INDEXES;
82
83		if (shiftedIndex < templateArgs.length) {
84		return toDebugString(templateArgs[shiftedIndex]);
85		}
86
87		return match;
88		});
89
90		message += '\nhttp://errors.angularjs.org/1.5.0/' +
91		(module ? module + '/' : '') + code;
92
93		for (i = SKIP_INDEXES, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') {
94		message += paramPrefix + 'p' + (i - SKIP_INDEXES) + '=' +
95		encodeURIComponent(toDebugString(templateArgs[i]));
96		}
97
98		return new ErrorConstructor(message);
99		};
100		}
101
102		/**
103		* @ngdoc type
104		* @name angular.Module
105		* @module ng
106		* @description
107		*
108		* Interface for configuring angular {@link angular.module modules}.
109		*/
110
111	View Code Duplication	function setupModuleLoader(window) {
112
113		var $injectorMinErr = minErr('$injector');
114		var ngMinErr = minErr('ng');
115
116		function ensure(obj, name, factory) {
117		return obj[name] \|\| (obj[name] = factory());
118		}
119
120		var angular = ensure(window, 'angular', Object);
121
122		// We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
123		angular.$$minErr = angular.$$minErr \|\| minErr;
124
125		return ensure(angular, 'module', function() {
126		/** @type {Object.<string, angular.Module>} */
127		var modules = {};
128
129		/**
130		* @ngdoc function
131		* @name angular.module
132		* @module ng
133		* @description
134		*
135		* The `angular.module` is a global place for creating, registering and retrieving Angular
136		* modules.
137		* All modules (angular core or 3rd party) that should be available to an application must be
138		* registered using this mechanism.
139		*
140		* Passing one argument retrieves an existing {@link angular.Module},
141		* whereas passing more than one argument creates a new {@link angular.Module}
142		*
143		*
144		* # Module
145		*
146		* A module is a collection of services, directives, controllers, filters, and configuration information.
147		* `angular.module` is used to configure the {@link auto.$injector $injector}.
148		*
149		* ```js
150		* // Create a new module
151		* var myModule = angular.module('myModule', []);
152		*
153		* // register a new service
154		* myModule.value('appName', 'MyCoolApp');
155		*
156		* // configure existing services inside initialization blocks.
157		* myModule.config(['$locationProvider', function($locationProvider) {
158		* // Configure existing providers
159		* $locationProvider.hashPrefix('!');
160		* }]);
161		* ```
162		*
163		* Then you can create an injector and load your modules like this:
164		*
165		* ```js
166		* var injector = angular.injector(['ng', 'myModule'])
167		* ```
168		*
169		* However it's more likely that you'll just use
170		* {@link ng.directive:ngApp ngApp} or
171		* {@link angular.bootstrap} to simplify this process for you.
172		*
173		* @param {!string} name The name of the module to create or retrieve.
174		* @param {!Array.<string>=} requires If specified then new module is being created. If
175		* unspecified then the module is being retrieved for further configuration.
176		* @param {Function=} configFn Optional configuration function for the module. Same as
177		* {@link angular.Module#config Module#config()}.
178		* @returns {angular.Module} new module with the {@link angular.Module} api.
179		*/
180		return function module(name, requires, configFn) {
181		var assertNotHasOwnProperty = function(name, context) {
182		if (name === 'hasOwnProperty') {
183		throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);
184		}
185		};
186
187		assertNotHasOwnProperty(name, 'module');
188		if (requires && modules.hasOwnProperty(name)) {
189		modules[name] = null;
190		}
191		return ensure(modules, name, function() {
192		if (!requires) {
193		throw $injectorMinErr('nomod', "Module '{0}' is not available! You either misspelled " +
194		"the module name or forgot to load it. If registering a module ensure that you " +
195		"specify the dependencies as the second argument.", name);
196		}
197
198		/** @type {!Array.<Array.<>>} /
199		var invokeQueue = [];
200
201		/** @type {!Array.<Function>} */
202		var configBlocks = [];
203
204		/** @type {!Array.<Function>} */
205		var runBlocks = [];
206
207		var config = invokeLater('$injector', 'invoke', 'push', configBlocks);
208
209		/** @type {angular.Module} */
210		var moduleInstance = {
211		// Private state
212		_invokeQueue: invokeQueue,
213		_configBlocks: configBlocks,
214		_runBlocks: runBlocks,
215
216		/**
217		* @ngdoc property
218		* @name angular.Module#requires
219		* @module ng
220		*
221		* @description
222		* Holds the list of modules which the injector will load before the current module is
223		* loaded.
224		*/
225		requires: requires,
226
227		/**
228		* @ngdoc property
229		* @name angular.Module#name
230		* @module ng
231		*
232		* @description
233		* Name of the module.
234		*/
235		name: name,
236
237
238		/**
239		* @ngdoc method
240		* @name angular.Module#provider
241		* @module ng
242		* @param {string} name service name
243		* @param {Function} providerType Construction function for creating new instance of the
244		* service.
245		* @description
246		* See {@link auto.$provide#provider $provide.provider()}.
247		*/
248		provider: invokeLaterAndSetModuleName('$provide', 'provider'),
249
250		/**
251		* @ngdoc method
252		* @name angular.Module#factory
253		* @module ng
254		* @param {string} name service name
255		* @param {Function} providerFunction Function for creating new instance of the service.
256		* @description
257		* See {@link auto.$provide#factory $provide.factory()}.
258		*/
259		factory: invokeLaterAndSetModuleName('$provide', 'factory'),
260
261		/**
262		* @ngdoc method
263		* @name angular.Module#service
264		* @module ng
265		* @param {string} name service name
266		* @param {Function} constructor A constructor function that will be instantiated.
267		* @description
268		* See {@link auto.$provide#service $provide.service()}.
269		*/
270		service: invokeLaterAndSetModuleName('$provide', 'service'),
271
272		/**
273		* @ngdoc method
274		* @name angular.Module#value
275		* @module ng
276		* @param {string} name service name
277		* @param {*} object Service instance object.
278		* @description
279		* See {@link auto.$provide#value $provide.value()}.
280		*/
281		value: invokeLater('$provide', 'value'),
282
283		/**
284		* @ngdoc method
285		* @name angular.Module#constant
286		* @module ng
287		* @param {string} name constant name
288		* @param {*} object Constant value.
289		* @description
290		* Because the constants are fixed, they get applied before other provide methods.
291		* See {@link auto.$provide#constant $provide.constant()}.
292		*/
293		constant: invokeLater('$provide', 'constant', 'unshift'),
294
295		/**
296		* @ngdoc method
297		* @name angular.Module#decorator
298		* @module ng
299		* @param {string} The name of the service to decorate.
300		* @param {Function} This function will be invoked when the service needs to be
301		* instantiated and should return the decorated service instance.
302		* @description
303		* See {@link auto.$provide#decorator $provide.decorator()}.
304		*/
305		decorator: invokeLaterAndSetModuleName('$provide', 'decorator'),
306
307		/**
308		* @ngdoc method
309		* @name angular.Module#animation
310		* @module ng
311		* @param {string} name animation name
312		* @param {Function} animationFactory Factory function for creating new instance of an
313		* animation.
314		* @description
315		*
316		* NOTE: animations take effect only if the ngAnimate module is loaded.
317		*
318		*
319		* Defines an animation hook that can be later used with
320		* {@link $animate $animate} service and directives that use this service.
321		*
322		* ```js
323		* module.animation('.animation-name', function($inject1, $inject2) {
324		* return {
325		* eventName : function(element, done) {
326		* //code to run the animation
327		* //once complete, then run done()
328		* return function cancellationFunction(element) {
329		* //code to cancel the animation
330		* }
331		* }
332		* }
333		* })
334		* ```
335		*
336		* See {@link ng.$animateProvider#register $animateProvider.register()} and
337		* {@link ngAnimate ngAnimate module} for more information.
338		*/
339		animation: invokeLaterAndSetModuleName('$animateProvider', 'register'),
340
341		/**
342		* @ngdoc method
343		* @name angular.Module#filter
344		* @module ng
345		* @param {string} name Filter name - this must be a valid angular expression identifier
346		* @param {Function} filterFactory Factory function for creating new instance of filter.
347		* @description
348		* See {@link ng.$filterProvider#register $filterProvider.register()}.
349		*
350		* <div class="alert alert-warning">
351		* Note: Filter names must be valid angular {@link expression} identifiers, such as `uppercase` or `orderBy`.
352		* Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
353		* your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
354		* (`myapp_subsection_filterx`).
355		* </div>
356		*/
357		filter: invokeLaterAndSetModuleName('$filterProvider', 'register'),
358
359		/**
360		* @ngdoc method
361		* @name angular.Module#controller
362		* @module ng
363		* @param {string\|Object} name Controller name, or an object map of controllers where the
364		* keys are the names and the values are the constructors.
365		* @param {Function} constructor Controller constructor function.
366		* @description
367		* See {@link ng.$controllerProvider#register $controllerProvider.register()}.
368		*/
369		controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'),
370
371		/**
372		* @ngdoc method
373		* @name angular.Module#directive
374		* @module ng
375		* @param {string\|Object} name Directive name, or an object map of directives where the
376		* keys are the names and the values are the factories.
377		* @param {Function} directiveFactory Factory function for creating new instance of
378		* directives.
379		* @description
380		* See {@link ng.$compileProvider#directive $compileProvider.directive()}.
381		*/
382		directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'),
383
384		/**
385		* @ngdoc method
386		* @name angular.Module#component
387		* @module ng
388		* @param {string} name Name of the component in camel-case (i.e. myComp which will match as my-comp)
389		* @param {Object} options Component definition object (a simplified
390		* {@link ng.$compile#directive-definition-object directive definition object})
391		*
392		* @description
393		* See {@link ng.$compileProvider#component $compileProvider.component()}.
394		*/
395		component: invokeLaterAndSetModuleName('$compileProvider', 'component'),
396
397		/**
398		* @ngdoc method
399		* @name angular.Module#config
400		* @module ng
401		* @param {Function} configFn Execute this function on module load. Useful for service
402		* configuration.
403		* @description
404		* Use this method to register work which needs to be performed on module loading.
405		* For more about how to configure services, see
406		* {@link providers#provider-recipe Provider Recipe}.
407		*/
408		config: config,
409
410		/**
411		* @ngdoc method
412		* @name angular.Module#run
413		* @module ng
414		* @param {Function} initializationFn Execute this function after injector creation.
415		* Useful for application initialization.
416		* @description
417		* Use this method to register work which should be performed when the injector is done
418		* loading all modules.
419		*/
420		run: function(block) {
421		runBlocks.push(block);
422		return this;
423		}
424		};
425
426		if (configFn) {
427		config(configFn);
428		}
429
430		return moduleInstance;
431
432		/**
433		* @param {string} provider
434		* @param {string} method
435		* @param {String=} insertMethod
436		* @returns {angular.Module}
437		*/
438		function invokeLater(provider, method, insertMethod, queue) {
439		if (!queue) queue = invokeQueue;
440		return function() {
441		queue[insertMethod \|\| 'push']([provider, method, arguments]);
442		return moduleInstance;
443		};
444		}
445
446		/**
447		* @param {string} provider
448		* @param {string} method
449		* @returns {angular.Module}
450		*/
451		function invokeLaterAndSetModuleName(provider, method) {
452		return function(recipeName, factoryFunction) {
453		if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
454		invokeQueue.push([provider, method, arguments]);
455		return moduleInstance;
456		};
457		}
458		});
459		};
460		});
461
462		}
463
464		setupModuleLoader(window);
465		})(window);
466
467		/**
468		* Closure compiler type information
469		*
470		* @typedef { {
471		* requires: !Array.<string>,
472		* invokeQueue: !Array.<Array.<*>>,
473		*
474		* service: function(string, Function):angular.Module,
475		* factory: function(string, Function):angular.Module,
476		* value: function(string, *):angular.Module,
477		*
478		* filter: function(string, Function):angular.Module,
479		*
480		* init: function(Function):angular.Module
481		* } }
482		*/
483		angular.Module;
		0 ignored issues – show introduced 2019-02-08 08:36 UTC by Report Bug Copy Issue Report The result of the property access to `angular.Module` is not used. Loading history...
484
485

Otaku-Projects / AngularJS-CRUD-PHP

GitHub Access Token became invalid

angular-loader.js ➔ minErr B last analyzed 2020-01-16 17:41 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

angular-loader.js ➔ minErr B
last analyzed 2020-01-16 17:41 UTC